node_base.h

Go to the documentation of this file.

// WOLF - Copyright (C) 2020-2026
// Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
// Authors: Joan Solà Ortega (jsola@iri.upc.edu) and
// Joan Vallvé Navarro (jvallve@iri.upc.edu)
// All rights reserved.
//
// This file is part of WOLF: http://www.iri.upc.edu/wolf
// WOLF is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
 
// Wolf includes
#include "core/common/wolf.h"
#include "core/utils/check_log.h"
 
namespace wolf
{
class NodeBase
{
    friend Problem;
 
  private:
    static unsigned int node_id_count_;  
 
    struct Serializer;
 
  protected:
    ProblemWPtr problem_ptr_;
 
    unsigned int node_id_;        
    std::string  node_category_;  
    std::string  node_type_;  
    std::string  node_name_;  
 
    bool is_removing_;  
 
    virtual void setProblem(ProblemPtr _prob_ptr);
 
  public:
    NodeBase(const std::string& _category, const std::string& _type = "Undefined", const std::string& _name = "");
    virtual ~NodeBase() = default;
 
    unsigned int nodeId() const;
    std::string  getCategory() const;
    std::string  getType() const;
    std::string  getName() const;
    bool         isRemoving() const;
    virtual bool hasChildren() const = 0;
 
    void            setType(const std::string& _type);
    void            setName(const std::string& _name);
    ProblemConstPtr getProblem() const;
    ProblemPtr      getProblem();
};
 
}  // namespace wolf
 
#include <iostream>
 
namespace wolf
{
inline NodeBase::NodeBase(const std::string& _category, const std::string& _type, const std::string& _name)
    : problem_ptr_(),  // nullptr
      node_id_(++node_id_count_),
      node_category_(_category),
      node_type_(_type),
      node_name_(_name),
      is_removing_(false)
{
    //
}
 
inline unsigned int NodeBase::nodeId() const
{
    return node_id_;
}
 
inline std::string NodeBase::getCategory() const
{
    return node_category_;
}
 
inline std::string NodeBase::getType() const
{
    return node_type_;
}
 
inline std::string NodeBase::getName() const
{
    return node_name_;
}
 
inline bool NodeBase::isRemoving() const
{
    return is_removing_;
}
 
inline void NodeBase::setType(const std::string& _type)
{
    node_type_ = _type;
}
 
inline void NodeBase::setName(const std::string& _name)
{
    node_name_ = _name;
}
 
inline ProblemConstPtr NodeBase::getProblem() const
{
    return problem_ptr_.lock();
}
 
inline ProblemPtr NodeBase::getProblem()
{
    return problem_ptr_.lock();
}
 
inline void NodeBase::setProblem(ProblemPtr _prob_ptr)
{
    problem_ptr_ = _prob_ptr;
}
 
}  // namespace wolf